home *** CD-ROM | disk | FTP | other *** search
/ EuroCD 3 / EuroCD 3.iso / Games / Doom / ADoom-0.8 / ADoom_src / p_mobj.c < prev    next >
C/C++ Source or Header  |  1998-06-24  |  19KB  |  993 lines
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. //    Moving object handling. Spawn functions.
  21. //
  22. //-----------------------------------------------------------------------------
  23.  
  24. static const char
  25. rcsid[] = "$Id: p_mobj.c,v 1.5 1997/02/03 22:45:12 b1 Exp $";
  26.  
  27. #include "i_system.h"
  28. #include "z_zone.h"
  29. #include "m_random.h"
  30.  
  31. #include "doomdef.h"
  32. #include "p_local.h"
  33. #include "sounds.h"
  34.  
  35. #include "st_stuff.h"
  36. #include "hu_stuff.h"
  37.  
  38. #include "s_sound.h"
  39.  
  40. #include "doomstat.h"
  41.  
  42.  
  43. void G_PlayerReborn (int player);
  44. void P_SpawnMapThing (mapthing_t*    mthing);
  45.  
  46.  
  47. //
  48. // P_SetMobjState
  49. // Returns true if the mobj is still present.
  50. //
  51. int test;
  52.  
  53. boolean
  54. P_SetMobjState
  55. ( mobj_t*    mobj,
  56.   statenum_t    state )
  57. {
  58.     state_t*    st;
  59.  
  60.     do
  61.     {
  62.     if (state == S_NULL)
  63.     {
  64.         mobj->state = (state_t *) S_NULL;
  65.         P_RemoveMobj (mobj);
  66.         return false;
  67.     }
  68.  
  69.     st = &states[state];
  70.     mobj->state = st;
  71.     mobj->tics = st->tics;
  72.     mobj->sprite = st->sprite;
  73.     mobj->frame = st->frame;
  74.  
  75.     // Modified handling.
  76.     // Call action functions when the state is set
  77.     if (st->action.acp1)        
  78.         st->action.acp1(mobj);    
  79.     
  80.     state = st->nextstate;
  81.     } while (!mobj->tics);
  82.                 
  83.     return true;
  84. }
  85.  
  86.  
  87. //
  88. // P_ExplodeMissile  
  89. //
  90. void P_ExplodeMissile (mobj_t* mo)
  91. {
  92.     mo->momx = mo->momy = mo->momz = 0;
  93.  
  94.     P_SetMobjState (mo, mobjinfo[mo->type].deathstate);
  95.  
  96.     mo->tics -= P_Random()&3;
  97.  
  98.     if (mo->tics < 1)
  99.     mo->tics = 1;
  100.  
  101.     mo->flags &= ~MF_MISSILE;
  102.  
  103.     if (mo->info->deathsound)
  104.     S_StartSound (mo, mo->info->deathsound);
  105. }
  106.  
  107.  
  108. //
  109. // P_XYMovement  
  110. //
  111. #define STOPSPEED        0x1000
  112. #define FRICTION        0xe800
  113.  
  114. void P_XYMovement (mobj_t* mo) 
  115. {     
  116.     fixed_t     ptryx;
  117.     fixed_t    ptryy;
  118.     player_t*    player;
  119.     fixed_t    xmove;
  120.     fixed_t    ymove;
  121.             
  122.     if (!mo->momx && !mo->momy)
  123.     {
  124.     if (mo->flags & MF_SKULLFLY)
  125.     {
  126.         // the skull slammed into something
  127.         mo->flags &= ~MF_SKULLFLY;
  128.         mo->momx = mo->momy = mo->momz = 0;
  129.  
  130.         P_SetMobjState (mo, mo->info->spawnstate);
  131.     }
  132.     return;
  133.     }
  134.     
  135.     player = mo->player;
  136.         
  137.     if (mo->momx > MAXMOVE)
  138.     mo->momx = MAXMOVE;
  139.     else if (mo->momx < -MAXMOVE)
  140.     mo->momx = -MAXMOVE;
  141.  
  142.     if (mo->momy > MAXMOVE)
  143.     mo->momy = MAXMOVE;
  144.     else if (mo->momy < -MAXMOVE)
  145.     mo->momy = -MAXMOVE;
  146.         
  147.     xmove = mo->momx;
  148.     ymove = mo->momy;
  149.     
  150.     do
  151.     {
  152.     if (xmove > MAXMOVE/2 || ymove > MAXMOVE/2)
  153.     {
  154.         ptryx = mo->x + xmove/2;
  155.         ptryy = mo->y + ymove/2;
  156.         xmove >>= 1;
  157.         ymove >>= 1;
  158.     }
  159.     else
  160.     {
  161.         ptryx = mo->x + xmove;
  162.         ptryy = mo->y + ymove;
  163.         xmove = ymove = 0;
  164.     }
  165.         
  166.     if (!P_TryMove (mo, ptryx, ptryy))
  167.     {
  168.         // blocked move
  169.         if (mo->player)
  170.         {    // try to slide along it
  171.         P_SlideMove (mo);
  172.         }
  173.         else if (mo->flags & MF_MISSILE)
  174.         {
  175.         // explode a missile
  176.         if (ceilingline &&
  177.             ceilingline->backsector &&
  178.             ceilingline->backsector->ceilingpic == skyflatnum)
  179.         {
  180.             // Hack to prevent missiles exploding
  181.             // against the sky.
  182.             // Does not handle sky floors.
  183.             P_RemoveMobj (mo);
  184.             return;
  185.         }
  186.         P_ExplodeMissile (mo);
  187.         }
  188.         else
  189.         mo->momx = mo->momy = 0;
  190.     }
  191.     } while (xmove || ymove);
  192.     
  193.     // slow down
  194.     if (player && player->cheats & CF_NOMOMENTUM)
  195.     {
  196.     // debug option for no sliding at all
  197.     mo->momx = mo->momy = 0;
  198.     return;
  199.     }
  200.  
  201.     if (mo->flags & (MF_MISSILE | MF_SKULLFLY) )
  202.     return;     // no friction for missiles ever
  203.         
  204.     if (mo->z > mo->floorz)
  205.     return;        // no friction when airborne
  206.  
  207.     if (mo->flags & MF_CORPSE)
  208.     {
  209.     // do not stop sliding
  210.     //  if halfway off a step with some momentum
  211.     if (mo->momx > FRACUNIT/4
  212.         || mo->momx < -FRACUNIT/4
  213.         || mo->momy > FRACUNIT/4
  214.         || mo->momy < -FRACUNIT/4)
  215.     {
  216.         if (mo->floorz != mo->subsector->sector->floorheight)
  217.         return;
  218.     }
  219.     }
  220.  
  221.     if (mo->momx > -STOPSPEED
  222.     && mo->momx < STOPSPEED
  223.     && mo->momy > -STOPSPEED
  224.     && mo->momy < STOPSPEED
  225.     && (!player
  226.         || (player->cmd.forwardmove== 0
  227.         && player->cmd.sidemove == 0 ) ) )
  228.     {
  229.     // if in a walking frame, stop moving
  230.     if ( player&&(unsigned)((player->mo->state - states)- S_PLAY_RUN1) < 4)
  231.         P_SetMobjState (player->mo, S_PLAY);
  232.     
  233.     mo->momx = 0;
  234.     mo->momy = 0;
  235.     }
  236.     else
  237.     {
  238.     mo->momx = FixedMul (mo->momx, FRICTION);
  239.     mo->momy = FixedMul (mo->momy, FRICTION);
  240.     }
  241. }
  242.  
  243. //
  244. // P_ZMovement
  245. //
  246. void P_ZMovement (mobj_t* mo)
  247. {
  248.     fixed_t    dist;
  249.     fixed_t    delta;
  250.     
  251.     // check for smooth step up
  252.     if (mo->player && mo->z < mo->floorz)
  253.     {
  254.     mo->player->viewheight -= mo->floorz-mo->z;
  255.  
  256.     mo->player->deltaviewheight
  257.         = (VIEWHEIGHT - mo->player->viewheight)>>3;
  258.     }
  259.     
  260.     // adjust height
  261.     mo->z += mo->momz;
  262.     
  263.     if ( mo->flags & MF_FLOAT
  264.      && mo->target)
  265.     {
  266.     // float down towards target if too close
  267.     if ( !(mo->flags & MF_SKULLFLY)
  268.          && !(mo->flags & MF_INFLOAT) )
  269.     {
  270.         dist = P_AproxDistance (mo->x - mo->target->x,
  271.                     mo->y - mo->target->y);
  272.         
  273.         delta =(mo->target->z + (mo->height>>1)) - mo->z;
  274.  
  275.         if (delta<0 && dist < -(delta*3) )
  276.         mo->z -= FLOATSPEED;
  277.         else if (delta>0 && dist < (delta*3) )
  278.         mo->z += FLOATSPEED;            
  279.     }
  280.     
  281.     }
  282.     
  283.     // clip movement
  284.     if (mo->z <= mo->floorz)
  285.     {
  286.     // hit the floor
  287.  
  288.     // Note (id):
  289.     //  somebody left this after the setting momz to 0,
  290.     //  kinda useless there.
  291.     if (mo->flags & MF_SKULLFLY)
  292.     {
  293.         // the skull slammed into something
  294.         mo->momz = -mo->momz;
  295.     }
  296.     
  297.     if (mo->momz < 0)
  298.     {
  299.         if (mo->player
  300.         && mo->momz < -GRAVITY*8)    
  301.         {
  302.         // Squat down.
  303.         // Decrease viewheight for a moment
  304.         // after hitting the ground (hard),
  305.         // and utter appropriate sound.
  306.         mo->player->deltaviewheight = mo->momz>>3;
  307.         S_StartSound (mo, sfx_oof);
  308.         }
  309.         mo->momz = 0;
  310.     }
  311.     mo->z = mo->floorz;
  312.  
  313.     if ( (mo->flags & MF_MISSILE)
  314.          && !(mo->flags & MF_NOCLIP) )
  315.     {
  316.         P_ExplodeMissile (mo);
  317.         return;
  318.     }
  319.     }
  320.     else if (! (mo->flags & MF_NOGRAVITY) )
  321.     {
  322.     if (mo->momz == 0)
  323.         mo->momz = -GRAVITY*2;
  324.     else
  325.         mo->momz -= GRAVITY;
  326.     }
  327.     
  328.     if (mo->z + mo->height > mo->ceilingz)
  329.     {
  330.     // hit the ceiling
  331.     if (mo->momz > 0)
  332.         mo->momz = 0;
  333.     {
  334.         mo->z = mo->ceilingz - mo->height;
  335.     }
  336.  
  337.     if (mo->flags & MF_SKULLFLY)
  338.     {    // the skull slammed into something
  339.         mo->momz = -mo->momz;
  340.     }
  341.     
  342.     if ( (mo->flags & MF_MISSILE)
  343.          && !(mo->flags & MF_NOCLIP) )
  344.     {
  345.         P_ExplodeMissile (mo);
  346.         return;
  347.     }
  348.     }
  349. } 
  350.  
  351.  
  352.  
  353. //
  354. // P_NightmareRespawn
  355. //
  356. void
  357. P_NightmareRespawn (mobj_t* mobj)
  358. {
  359.     fixed_t        x;
  360.     fixed_t        y;
  361.     fixed_t        z; 
  362.     subsector_t*    ss; 
  363.     mobj_t*        mo;
  364.     mapthing_t*        mthing;
  365.         
  366.     x = mobj->spawnpoint.x << FRACBITS; 
  367.     y = mobj->spawnpoint.y << FRACBITS; 
  368.  
  369.     // somthing is occupying it's position?
  370.     if (!P_CheckPosition (mobj, x, y) ) 
  371.     return;    // no respwan
  372.  
  373.     // spawn a teleport fog at old spot
  374.     // because of removal of the body?
  375.     mo = P_SpawnMobj (mobj->x,
  376.               mobj->y,
  377.               mobj->subsector->sector->floorheight , MT_TFOG); 
  378.     // initiate teleport sound
  379.     S_StartSound (mo, sfx_telept);
  380.  
  381.     // spawn a teleport fog at the new spot
  382.     ss = R_PointInSubsector (x,y); 
  383.  
  384.     mo = P_SpawnMobj (x, y, ss->sector->floorheight , MT_TFOG); 
  385.  
  386.     S_StartSound (mo, sfx_telept);
  387.  
  388.     // spawn the new monster
  389.     mthing = &mobj->spawnpoint;
  390.     
  391.     // spawn it
  392.     if (mobj->info->flags & MF_SPAWNCEILING)
  393.     z = ONCEILINGZ;
  394.     else
  395.     z = ONFLOORZ;
  396.  
  397.     // inherit attributes from deceased one
  398.     mo = P_SpawnMobj (x,y,z, mobj->type);
  399.     mo->spawnpoint = mobj->spawnpoint;    
  400.     mo->angle = ANG45 * (mthing->angle/45);
  401.  
  402.     if (mthing->options & MTF_AMBUSH)
  403.     mo->flags |= MF_AMBUSH;
  404.  
  405.     mo->reactiontime = 18;
  406.     
  407.     // remove the old monster,
  408.     P_RemoveMobj (mobj);
  409. }
  410.  
  411.  
  412. //
  413. // P_MobjThinker
  414. //
  415. #ifdef __SASC
  416. __far void P_MobjThinker (mobj_t* mobj)
  417. #else
  418. void P_MobjThinker (mobj_t* mobj)
  419. #endif
  420. {
  421.     // momentum movement
  422.     if (mobj->momx
  423.     || mobj->momy
  424.     || (mobj->flags&MF_SKULLFLY) )
  425.     {
  426.     P_XYMovement (mobj);
  427.  
  428.     // FIXME: decent NOP/NULL/Nil function pointer please.
  429.     if (mobj->thinker.function.acv == (actionf_v) (-1))
  430.         return;        // mobj was removed
  431.     }
  432.     if ( (mobj->z != mobj->floorz)
  433.      || mobj->momz )
  434.     {
  435.     P_ZMovement (mobj);
  436.     
  437.     // FIXME: decent NOP/NULL/Nil function pointer please.
  438.     if (mobj->thinker.function.acv == (actionf_v) (-1))
  439.         return;        // mobj was removed
  440.     }
  441.  
  442.     
  443.     // cycle through states,
  444.     // calling action functions at transitions
  445.     if (mobj->tics != -1)
  446.     {
  447.     mobj->tics--;
  448.         
  449.     // you can cycle through multiple states in a tic
  450.     if (!mobj->tics)
  451.         if (!P_SetMobjState (mobj, mobj->state->nextstate) )
  452.         return;        // freed itself
  453.     }
  454.     else
  455.     {
  456.     // check for nightmare respawn
  457.     if (! (mobj->flags & MF_COUNTKILL) )
  458.         return;
  459.  
  460.     if (!respawnmonsters)
  461.         return;
  462.  
  463.     mobj->movecount++;
  464.  
  465.     if (mobj->movecount < 12*35)
  466.         return;
  467.  
  468.     if ( leveltime&31 )
  469.         return;
  470.  
  471.     if (P_Random () > 4)
  472.         return;
  473.  
  474.     P_NightmareRespawn (mobj);
  475.     }
  476.  
  477. }
  478.  
  479.  
  480. //
  481. // P_SpawnMobj
  482. //
  483. mobj_t*
  484. P_SpawnMobj
  485. ( fixed_t    x,
  486.   fixed_t    y,
  487.   fixed_t    z,
  488.   mobjtype_t    type )
  489. {
  490.     mobj_t*    mobj;
  491.     state_t*    st;
  492.     mobjinfo_t*    info;
  493.     
  494.     mobj = Z_Malloc (sizeof(*mobj), PU_LEVEL, NULL);
  495.     memset (mobj, 0, sizeof (*mobj));
  496.     info = &mobjinfo[type];
  497.     
  498.     mobj->type = type;
  499.     mobj->info = info;
  500.     mobj->x = x;
  501.     mobj->y = y;
  502.     mobj->radius = info->radius;
  503.     mobj->height = info->height;
  504.     mobj->flags = info->flags;
  505.     mobj->health = info->spawnhealth;
  506.  
  507.     if (gameskill != sk_nightmare)
  508.     mobj->reactiontime = info->reactiontime;
  509.     
  510.     mobj->lastlook = P_Random () % MAXPLAYERS;
  511.     // do not set the state with P_SetMobjState,
  512.     // because action routines can not be called yet
  513.     st = &states[info->spawnstate];
  514.  
  515.     mobj->state = st;
  516.     mobj->tics = st->tics;
  517.     mobj->sprite = st->sprite;
  518.     mobj->frame = st->frame;
  519.  
  520.     // set subsector and/or block links
  521.     P_SetThingPosition (mobj);
  522.     
  523.     mobj->floorz = mobj->subsector->sector->floorheight;
  524.     mobj->ceilingz = mobj->subsector->sector->ceilingheight;
  525.  
  526.     if (z == ONFLOORZ)
  527.     mobj->z = mobj->floorz;
  528.     else if (z == ONCEILINGZ)
  529.     mobj->z = mobj->ceilingz - mobj->info->height;
  530.     else 
  531.     mobj->z = z;
  532.  
  533.     mobj->thinker.function.acp1 = (actionf_p1)P_MobjThinker;
  534.     
  535.     P_AddThinker (&mobj->thinker);
  536.  
  537.     return mobj;
  538. }
  539.  
  540.  
  541. //
  542. // P_RemoveMobj
  543. //
  544. mapthing_t    itemrespawnque[ITEMQUESIZE];
  545. int        itemrespawntime[ITEMQUESIZE];
  546. int        iquehead;
  547. int        iquetail;
  548.  
  549.  
  550. void P_RemoveMobj (mobj_t* mobj)
  551. {
  552.     if ((mobj->flags & MF_SPECIAL)
  553.     && !(mobj->flags & MF_DROPPED)
  554.     && (mobj->type != MT_INV)
  555.     && (mobj->type != MT_INS))
  556.     {
  557.     itemrespawnque[iquehead] = mobj->spawnpoint;
  558.     itemrespawntime[iquehead] = leveltime;
  559.     iquehead = (iquehead+1)&(ITEMQUESIZE-1);
  560.  
  561.     // lose one off the end?
  562.     if (iquehead == iquetail)
  563.         iquetail = (iquetail+1)&(ITEMQUESIZE-1);
  564.     }
  565.     
  566.     // unlink from sector and block lists
  567.     P_UnsetThingPosition (mobj);
  568.     
  569.     // stop any playing sound
  570.     S_StopSound (mobj);
  571.     
  572.     // free block
  573.     P_RemoveThinker ((thinker_t*)mobj);
  574. }
  575.  
  576.  
  577.  
  578.  
  579. //
  580. // P_RespawnSpecials
  581. //
  582. void P_RespawnSpecials (void)
  583. {
  584.     fixed_t        x;
  585.     fixed_t        y;
  586.     fixed_t        z;
  587.     
  588.     subsector_t*    ss; 
  589.     mobj_t*        mo;
  590.     mapthing_t*        mthing;
  591.     
  592.     int            i;
  593.  
  594.     // only respawn items in deathmatch
  595.     if (deathmatch != 2)
  596.     return;    // 
  597.  
  598.     // nothing left to respawn?
  599.     if (iquehead == iquetail)
  600.     return;        
  601.  
  602.     // wait at least 30 seconds
  603.     if (leveltime - itemrespawntime[iquetail] < 30*35)
  604.     return;            
  605.  
  606.     mthing = &itemrespawnque[iquetail];
  607.     
  608.     x = mthing->x << FRACBITS; 
  609.     y = mthing->y << FRACBITS; 
  610.       
  611.     // spawn a teleport fog at the new spot
  612.     ss = R_PointInSubsector (x,y); 
  613.     mo = P_SpawnMobj (x, y, ss->sector->floorheight , MT_IFOG); 
  614.     S_StartSound (mo, sfx_itmbk);
  615.  
  616.     // find which type to spawn
  617.     for (i=0 ; i< NUMMOBJTYPES ; i++)
  618.     {
  619.     if (mthing->type == mobjinfo[i].doomednum)
  620.         break;
  621.     }
  622.     
  623.     // spawn it
  624.     if (mobjinfo[i].flags & MF_SPAWNCEILING)
  625.     z = ONCEILINGZ;
  626.     else
  627.     z = ONFLOORZ;
  628.  
  629.     mo = P_SpawnMobj (x,y,z, i);
  630.     mo->spawnpoint = *mthing;    
  631.     mo->angle = ANG45 * (mthing->angle/45);
  632.  
  633.     // pull it from the que
  634.     iquetail = (iquetail+1)&(ITEMQUESIZE-1);
  635. }
  636.  
  637.  
  638.  
  639.  
  640. //
  641. // P_SpawnPlayer
  642. // Called when a player is spawned on the level.
  643. // Most of the player structure stays unchanged
  644. //  between levels.
  645. //
  646. void P_SpawnPlayer (mapthing_t* mthing)
  647. {
  648.     player_t*        p;
  649.     fixed_t        x;
  650.     fixed_t        y;
  651.     fixed_t        z;
  652.  
  653.     mobj_t*        mobj;
  654.  
  655.     int            i;
  656.  
  657.     // not playing?
  658.     if (!playeringame[mthing->type-1])
  659.     return;                    
  660.         
  661.     p = &players[mthing->type-1];
  662.  
  663.     if (p->playerstate == PST_REBORN)
  664.     G_PlayerReborn (mthing->type-1);
  665.  
  666.     x         = mthing->x << FRACBITS;
  667.     y         = mthing->y << FRACBITS;
  668.     z        = ONFLOORZ;
  669.     mobj    = P_SpawnMobj (x,y,z, MT_PLAYER);
  670.  
  671.     // set color translations for player sprites
  672.     if (mthing->type > 1)        
  673.     mobj->flags |= (mthing->type-1)<<MF_TRANSSHIFT;
  674.         
  675.     mobj->angle    = ANG45 * (mthing->angle/45);
  676.     mobj->player = p;
  677.     mobj->health = p->health;
  678.  
  679.     p->mo = mobj;
  680.     p->playerstate = PST_LIVE;    
  681.     p->refire = 0;
  682.     p->message = NULL;
  683.     p->damagecount = 0;
  684.     p->bonuscount = 0;
  685.     p->extralight = 0;
  686.     p->fixedcolormap = 0;
  687.     p->viewheight = VIEWHEIGHT;
  688.  
  689.     // setup gun psprite
  690.     P_SetupPsprites (p);
  691.     
  692.     // give all cards in death match mode
  693.     if (deathmatch)
  694.     for (i=0 ; i<NUMCARDS ; i++)
  695.         p->cards[i] = true;
  696.             
  697.     if (mthing->type-1 == consoleplayer)
  698.     {
  699.     // wake up the status bar
  700.     ST_Start ();
  701.     // wake up the heads up text
  702.     HU_Start ();        
  703.     }
  704. }
  705.  
  706.  
  707. //
  708. // P_SpawnMapThing
  709. // The fields of the mapthing should
  710. // already be in host byte order.
  711. //
  712. void P_SpawnMapThing (mapthing_t* mthing)
  713. {
  714.     int            i;
  715.     int            bit;
  716.     mobj_t*        mobj;
  717.     fixed_t        x;
  718.     fixed_t        y;
  719.     fixed_t        z;
  720.         
  721.     // count deathmatch start positions
  722.     if (mthing->type == 11)
  723.     {
  724.     if (deathmatch_p < &deathmatchstarts[10])
  725.     {
  726.         memcpy (deathmatch_p, mthing, sizeof(*mthing));
  727.         deathmatch_p++;
  728.     }
  729.     return;
  730.     }
  731.     
  732.     // check for players specially
  733.     if (mthing->type <= 4)
  734.     {
  735.     // save spots for respawning in network games
  736.     playerstarts[mthing->type-1] = *mthing;
  737.     if (!deathmatch)
  738.         P_SpawnPlayer (mthing);
  739.  
  740.     return;
  741.     }
  742.  
  743.     // check for apropriate skill level
  744.     if (!netgame && (mthing->options & 16) )
  745.     return;
  746.         
  747.     if (gameskill == sk_baby)
  748.     bit = 1;
  749.     else if (gameskill == sk_nightmare)
  750.     bit = 4;
  751.     else
  752.     bit = 1<<(gameskill-1);
  753.  
  754.     if (!(mthing->options & bit) )
  755.     return;
  756.     
  757.     // find which type to spawn
  758.     for (i=0 ; i< NUMMOBJTYPES ; i++)
  759.     if (mthing->type == mobjinfo[i].doomednum)
  760.         break;
  761.     
  762.     if (i==NUMMOBJTYPES)
  763.     I_Error ("P_SpawnMapThing: Unknown type %i at (%i, %i)",
  764.          mthing->type,
  765.          mthing->x, mthing->y);
  766.         
  767.     // don't spawn keycards and players in deathmatch
  768.     if (deathmatch && mobjinfo[i].flags & MF_NOTDMATCH)
  769.     return;
  770.         
  771.     // don't spawn any monsters if -nomonsters
  772.     if (nomonsters
  773.     && ( i == MT_SKULL
  774.          || (mobjinfo[i].flags & MF_COUNTKILL)) )
  775.     {
  776.     return;
  777.     }
  778.     
  779.     // spawn it
  780.     x = mthing->x << FRACBITS;
  781.     y = mthing->y << FRACBITS;
  782.  
  783.     if (mobjinfo[i].flags & MF_SPAWNCEILING)
  784.     z = ONCEILINGZ;
  785.     else
  786.     z = ONFLOORZ;
  787.     
  788.     mobj = P_SpawnMobj (x,y,z, i);
  789.     mobj->spawnpoint = *mthing;
  790.  
  791.     if (mobj->tics > 0)
  792.     mobj->tics = 1 + (P_Random () % mobj->tics);
  793.     if (mobj->flags & MF_COUNTKILL)
  794.     totalkills++;
  795.     if (mobj->flags & MF_COUNTITEM)
  796.     totalitems++;
  797.         
  798.     mobj->angle = ANG45 * (mthing->angle/45);
  799.     if (mthing->options & MTF_AMBUSH)
  800.     mobj->flags |= MF_AMBUSH;
  801. }
  802.  
  803.  
  804.  
  805. //
  806. // GAME SPAWN FUNCTIONS
  807. //
  808.  
  809.  
  810. //
  811. // P_SpawnPuff
  812. //
  813. extern fixed_t attackrange;
  814.  
  815. void
  816. P_SpawnPuff
  817. ( fixed_t    x,
  818.   fixed_t    y,
  819.   fixed_t    z )
  820. {
  821.     mobj_t*    th;
  822.     
  823.     z += ((P_Random()-P_Random())<<10);
  824.  
  825.     th = P_SpawnMobj (x,y,z, MT_PUFF);
  826.     th->momz = FRACUNIT;
  827.     th->tics -= P_Random()&3;
  828.  
  829.     if (th->tics < 1)
  830.     th->tics = 1;
  831.     
  832.     // don't make punches spark on the wall
  833.     if (attackrange == MELEERANGE)
  834.     P_SetMobjState (th, S_PUFF3);
  835. }
  836.  
  837.  
  838.  
  839. //
  840. // P_SpawnBlood
  841. // 
  842. void
  843. P_SpawnBlood
  844. ( fixed_t    x,
  845.   fixed_t    y,
  846.   fixed_t    z,
  847.   int        damage )
  848. {
  849.     mobj_t*    th;
  850.     
  851.     z += ((P_Random()-P_Random())<<10);
  852.     th = P_SpawnMobj (x,y,z, MT_BLOOD);
  853.     th->momz = FRACUNIT*2;
  854.     th->tics -= P_Random()&3;
  855.  
  856.     if (th->tics < 1)
  857.     th->tics = 1;
  858.         
  859.     if (damage <= 12 && damage >= 9)
  860.     P_SetMobjState (th,S_BLOOD2);
  861.     else if (damage < 9)
  862.     P_SetMobjState (th,S_BLOOD3);
  863. }
  864.  
  865.  
  866.  
  867. //
  868. // P_CheckMissileSpawn
  869. // Moves the missile forward a bit
  870. //  and possibly explodes it right there.
  871. //
  872. void P_CheckMissileSpawn (mobj_t* th)
  873. {
  874.     th->tics -= P_Random()&3;
  875.     if (th->tics < 1)
  876.     th->tics = 1;
  877.     
  878.     // move a little forward so an angle can
  879.     // be computed if it immediately explodes
  880.     th->x += (th->momx>>1);
  881.     th->y += (th->momy>>1);
  882.     th->z += (th->momz>>1);
  883.  
  884.     if (!P_TryMove (th, th->x, th->y))
  885.     P_ExplodeMissile (th);
  886. }
  887.  
  888.  
  889. //
  890. // P_SpawnMissile
  891. //
  892. mobj_t*
  893. P_SpawnMissile
  894. ( mobj_t*    source,
  895.   mobj_t*    dest,
  896.   mobjtype_t    type )
  897. {
  898.     mobj_t*    th;
  899.     angle_t    an;
  900.     int        dist;
  901.  
  902.     th = P_SpawnMobj (source->x,
  903.               source->y,
  904.               source->z + 4*8*FRACUNIT, type);
  905.     
  906.     if (th->info->seesound)
  907.     S_StartSound (th, th->info->seesound);
  908.  
  909.     th->target = source;    // where it came from
  910.     an = R_PointToAngle2 (source->x, source->y, dest->x, dest->y);    
  911.  
  912.     // fuzzy player
  913.     if (dest->flags & MF_SHADOW)
  914.     an += (P_Random()-P_Random())<<20;    
  915.  
  916.     th->angle = an;
  917.     an >>= ANGLETOFINESHIFT;
  918.     th->momx = FixedMul (th->info->speed, finecosine[an]);
  919.     th->momy = FixedMul (th->info->speed, finesine[an]);
  920.     
  921.     dist = P_AproxDistance (dest->x - source->x, dest->y - source->y);
  922.     dist = dist / th->info->speed;
  923.  
  924.     if (dist < 1)
  925.     dist = 1;
  926.  
  927.     th->momz = (dest->z - source->z) / dist;
  928.     P_CheckMissileSpawn (th);
  929.     
  930.     return th;
  931. }
  932.  
  933.  
  934. //
  935. // P_SpawnPlayerMissile
  936. // Tries to aim at a nearby monster
  937. //
  938. void
  939. P_SpawnPlayerMissile
  940. ( mobj_t*    source,
  941.   mobjtype_t    type )
  942. {
  943.     mobj_t*    th;
  944.     angle_t    an;
  945.     
  946.     fixed_t    x;
  947.     fixed_t    y;
  948.     fixed_t    z;
  949.     fixed_t    slope;
  950.     
  951.     // see which target is to be aimed at
  952.     an = source->angle;
  953.     slope = P_AimLineAttack (source, an, 16*64*FRACUNIT);
  954.     
  955.     if (!linetarget)
  956.     {
  957.     an += 1<<26;
  958.     slope = P_AimLineAttack (source, an, 16*64*FRACUNIT);
  959.  
  960.     if (!linetarget)
  961.     {
  962.         an -= 2<<26;
  963.         slope = P_AimLineAttack (source, an, 16*64*FRACUNIT);
  964.     }
  965.  
  966.     if (!linetarget)
  967.     {
  968.         an = source->angle;
  969.         slope = 0;
  970.     }
  971.     }
  972.         
  973.     x = source->x;
  974.     y = source->y;
  975.     z = source->z + 4*8*FRACUNIT;
  976.     
  977.     th = P_SpawnMobj (x,y,z, type);
  978.  
  979.     if (th->info->seesound)
  980.     S_StartSound (th, th->info->seesound);
  981.  
  982.     th->target = source;
  983.     th->angle = an;
  984.     th->momx = FixedMul( th->info->speed,
  985.              finecosine[an>>ANGLETOFINESHIFT]);
  986.     th->momy = FixedMul( th->info->speed,
  987.              finesine[an>>ANGLETOFINESHIFT]);
  988.     th->momz = FixedMul( th->info->speed, slope);
  989.  
  990.     P_CheckMissileSpawn (th);
  991. }
  992.  
  993.